יסודות מבני נתונים תרגול :9 ערימה - Heap
maximum שאלה: כמה זמן לוקח לחפש איבר בערימה? תשובה:,O(n) למרות שבערימה קיים סדר מסויים.
Heaps 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 דוגמה: 7 11 13 21 12 17 20 34 22 51 14 41 9 7 Heap_size 11 13 21 12 17 20 הוסיפו את 9 מוסיפים את הערך 9 כעלה מבצעים Up-Heapify לתיקון הערימה.1.2 34 22 51 14 41 9 קטן מאביו מבצעים החלפה
Heaps 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 דוגמה: 7 11 13 21 12 9 20 34 22 51 14 41 17 11 7 13 21 12 9 20 Heap_size הוסיפו את 9 מוסיפים את הערך 9 כעלה מבצעים Up-Heapify לתיקון הערימה גדול מאביו מסיימים קטן מאביו מבצעים החלפה.1.2 34 22 51 14 41 17
Heaps 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 7 11 9 21 12 13 20 34 22 51 14 41 דוגמה: 17 Key = 7 7 Heap_size 11 21 12 13 20 34 22 51 14 41 17 9 Extract- כעת בצעו min מוציאים את השורש )ושומרים את ערכו( מעבירים לשורש את העלה האחרון מבצעים Down-Heapify מהשורש לתיקון הערימה.1.2.3
Heaps 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 17 11 9 21 12 13 20 34 22 51 14 41 17 Key = 7 17 דוגמה: גדול מבנו הקטן מבצעים החלפה Heap_size 11 21 12 13 20 34 22 51 14 41 9 כעת בצעו Extract-min מוציאים את השורש )ושומרים את ערכו( מעבירים לשורש את העלה האחרון מבצעים Down-Heapify מהשורש לתיקון הערימה.1.2.3
Heaps 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 דוגמה: 9 11 17 21 12 13 20 34 22 51 14 41 17 Key = 7 9 Heap_size 11 17 21 12 13 20 34 22 51 14 41 Extract- כעת בצעו min מוציאים את השורש )ושומרים את ערכו( מעבירים לשורש את העלה האחרון מבצעים Down-Heapify מהשורש לתיקון הערימה מחזירים את הערך שנשמר גדול מבנו הקטן מבצעים החלפה קטן מבנו הקטן מסיימים.1.2.3.4
i Heaps 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 7 11 9 21 12 13 20 34 22 51 14 Key = 11 גדול מאביו מסיימים גדול מבנו הקטן מבצעים החלפה 11 7 קטן מבנו הקטן מסיימים 21 12 13 20 9 Heap_size הדגמה: מחקו את האיבר השני key H[i] H[i] H[heap_size] heap_size -- Down-Heapify(H, i) Up-Heapify(H, i) return key 34 22 51 14 אם כך, מדוע ייתכן שנצטרך לבצע?up-heapify
i Heaps 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 7 11 15 21 12 17 20 34 22 51 14 Key = 17 11 7 15 Heap_size 21 12 17 20 הדגמה: מחקו את האיבר השישי גדול מבנו הקטן מסיימים key H[i] H[i] H[heap_size] heap_size -- Down-Heapify(H, i) Up-Heapify(H, i) return key קטן מאביו מחליפים 34 22 51 14
i Heaps 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 7 11 15 21 12 14 20 34 22 51 14 Key = 17 11 7 Heap_size 15 21 12 14 20 הדגמה: מחקו את האיבר השישי key H[i] גדול מאביו מסיימים H[i] H[heap_size] heap_size -- Down-Heapify(H, i) Up-Heapify(H, i) return key 34 22 51
Heaps 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 7 11 13 21 12 17 20 34 22 51 14 41 7 Heap size 11 13 שאלה: האם במחיקת שורש האיבר שהועתק לשורש תמיד ידרוש תיקון? 21 12 17 20 34 22 51 14 41 תשובה: לא. לדוגמא, עץ עם שני צמתים, או עץ עם שלושה צמתים כך שהבן השמאלי של השורש יותר קטן מהבן הימני. שאלה: יש עוד דוגמאות כאילו?
Heaps 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 7 11 13 21 12 17 20 34 22 51 14 41 7 Heap size 11 13 שאלה: האם במחיקת שורש האיבר שהועתק לשורש תמיד ידרוש תיקון? 21 12 17 20 34 22 51 14 41 תשובה: לא. כדי שלא ידרש תיקון לאחר מחיקת השורש, העלה הימני ביותר חייב להיות גם האיבר השני בגודלו, ולכן צריך להמצא ברמה השנייה של העץ. לכן הדוגמאות לכך הם עצים עם לכל היותר שתי רמות.
Question 1 A max-heap is given as a heap-array A of size 15. The heap contains all keys in the range 1..15, each key exactly ones. 1. Where can be located the key 15? Specify possible indexes. Answer: A[1]. in a max-heap the maximum is always at the root. 2. Where can be located the key 1? Answer: anywhere on the last level, i.e., in A[8] A[15]. 3. Which keys can be located in A[2]? Answer: 7-14. We know that A is a complete tree, so a sub tree rooted by A[2] is also a complete tree with 7 nodes. Thus we need 6 elements smaller than A[2] to fill the sub tree of A[2], thus A[2] has to be at least 7. 3. Where can be located the key 13? Answer: in A[2] A[7]. There are exactly two elements larger than 13 (14, 15), so it can t reside lower than level 2. On level two it can reside anywhere.
Question 2 Suggest a data structure for storing integers that supports the following operations. Init(S) Initialize data structure with n elements of S set O(n) expected time Max() Return maximum O(1) expected time Insert(x) Insert x O(log n) expected time Delete(x) Delete x O(log n) expected time S = {9, 7, 5, 4, 2, 1} דוגמא :? O(logn) איך נמחוק בזמן max heap 1 2 4 נשמתש בטבלת גיבוב בנוסף, עם מצביעים לערימה 5 7 9 Delete (7) hash (7) = 7 get pointer to 7 in the heap delete 7
Question 3 Given a max-heap H, what is the time complexity of finding the 3 largest keys in H? פתרון: Y שלושה אלמנטים הגדולים ביותר בערימה הם: השורש הבן הגדול של השורש, נסמן אותו ב Y הגדול לבין הבן השני של השורש, ושני בניו של בסה"כ ביצענו השוואה אחת למצוא את האלמנט השני בגודלו, ושתי השוואות למצוא את האלמנט השלישי בגודלו, כלומר ביחד 3 השוואות.
Given a max-heap H, what is the time complexity of finding the K largest keys in H? פתרון: Question 3 אלמנטים הגדולים ביותר בערימה הם: הראשון בגודלו - השורש )מועמד יחיד( השני בגודלו - הבן הגדול של השורש, נסמן אותו ב Y )שני מועמדים, השוואה אחת( שלישי בגודלו - הגדול לבין הבן השני של השורש, ושני בניו של Y )שלושה מועמדים, שתי השוואות( ה Kי בגודלו לפי האבחנה הנ"ל, יהיו K מועמדים מהם יבחר (1-K השוואות( K בסה"כ כמות ההשוואות שנבצע היא: ) 2 1+2+3+ +K-1 K(K+1)/2 = O(K פתרון: נשתמש בערימת עזר אליה נכניס בהתחלה שורש של הערימה הקיימת. כל פעם נוציא מהערימה הזו מקסימום, ובמקומו נכניס את הבנים שלו מהערימה המקורית. כאשר איבר מוכנס לערימת עזר, הוא שומר מצביע על עצמו בערימה המקורית. זמן ריצה: בערימת עזר לכל היותר K איברים, בשלב שבו בוחרים את האיבר ה K י בגודלו. אז כל פעולת הכנסה והוצאת מקסימום לוקחת (k. O(log לכן, עבור K פעולות כאילו נבזבז logk) O(k זמן. עבודה עצמית: לשדרג את האלגוריתם הנ"ל כך שיעבוד בזמן logk) O(k
איברים בהתאמה.?O n 2 Question 4 נתונות שני ערימות מינימום H 1,H 2 עם n 1,n 2 כל האיברים ב H 1 קטנים האיברים ב H. 2 איך ניתן לאחד את הערימות לערימה אחת בזמן )ניתן להניח כי שתי הערימות משתמשות במערך < מ- n.( 1 + n 2 :n 1 n 2 נצרף את איברי. החל מאינדקס n 1 + 1 למערך של H 1 H 2 מכיוון שכל האיברים של קטנים מהאיברים של נקבל ערימה מאוחדת חוקית. H 2 H 1 פתרון: אם אם :n 2 > n 1 נבנה ערימה חדשה עם כל האיברים של H 1 H, 2 זמן ריצה : 2 O n 1 + n 2 = O 2n 2 = O n
Question 5 נתונים k מערכים ממויינים A 1, A, k עם מספר כולל של n ערכים כאשר k. n תארו אלגוריתם בזמן O n log k למיזוג של המערכים הנתונים למערך ממויין אחד. A 1 1 2 5 13 48 49 56 73... 94 A 2 3 25 32 37 62... 75 A 3 1 2 8... 33... A k 4 6 12 13 26 48... 99 merge 1 2 3
פתרון: רעיון נבנה ערימה שתשמור בכל שלב את האיברים החשודים להיות האיבר הקטן הבא. כלומר, נרצה לשמור את האיבר הראשון בכל אחד מהמערכים A. 1, A, k נשתמש בערימת מינימום אשר כל איבר בה הוא שלשה מהצורה (d,i,ad[i]) כאשר. 1 d k,1 i n הערימה תיוצג ע"י המערך B. ראשית נבנה ערימה עם האיברים הראשונים במערכים A 1, A, k בזמן O. k בכל צעד נוציא את האיבר המינימלי בערימה ונכניס אותו למערך הפלט M. נוציא את האיבר שהוצאנו מהמערך המקורי שלו ונביא משם את האיבר המינימלי הבא. Worst case time analysis: Build-Heap : O(k) done 1 time Extract-Min : O(log k) done n times Heap-Insert : O(log k) done n times Total: O(nlogk) Question 5 for d 1 to k B[d] (d, 1, A d [1]) Build-Heap(B) /*By the order of A d [1] */ for j=1 to n (d, i, x) Extract-Min(B) M[j] x if i < A d.length then Heap-Insert(B,(d, i+1, A d [i+1]))
Init Insert(x) FindMin() FindMax() DelMin() DelMax() n Question 6 נתונה קבוצה S המכילה n מספרים שלמים חיוביים. הציעו מבנה נתונים שמאחסן מספרים שלמים חיוביים, ותומך בפעולות הבאות. פתרון: ערימת מינימום H min משתנה נוסף max למקסימום שנעדכן אותו ב Insert למצוא מקסימום בערימת מינימום.O(n) אפשר להחזיק בנוסף לערך של מקסימום גם מצביע למקסימום בערימה. אבל צריך לאחר המחיקה של מקסימום גם לעדכן את המקסימום החדש O(n) כדי למצוא אותו. H min 4 5 4 11 9 8 max = 11 דוגמא : {7,5,9,4,8,11}
Init Insert(x) FindMin() FindMax() DelMin() DelMax() n Question 6 נתונה קבוצה S המכילה n מספרים שלמים חיוביים. הציעו מבנה נתונים שמאחסן מספרים שלמים חיוביים, ותומך בפעולות הבאות. פתרון: ערימת מינימום H min משתנה נוסף max למקסימום שנעדכן אותו ב Insert למצוא מקסימום בערימת מינימום.O(n) אפשר להחזיק בנוסף לערך של מקסימום גם מצביע למקסימום בערימה. אבל צריך לאחר המחיקה של מקסימום גם לעדכן את המקסימום החדש O(n) כדי למצוא אותו. H min 4 5 4 11 9 8 max = 11 דוגמא : {7,5,9,4,8,11}
Init Insert(x) n Question 6 נתונה קבוצה S המכילה n מספרים שלמים חיוביים. הציעו מבנה נתונים שמאחסן מספרים שלמים חיוביים, ותומך בפעולות הבאות. פתרון: FindMin() FindMax() נבנה שתי ערימות אחת מינימום H min והשנייה מקסימום ערימת מינימום ערימת מקסימום H min H max H max DelMin() DelMax() מחיקה מערימת מינימום O(logn) מחיקה מערימת מקסימום? צריך קודם לצמוא את האיבר המינימלי בה וזה לוקח O(n) זמן. H min H 4 max 11 5 8 8 4 11 9 4 5 7 9 H max מצביעים הדדיים בין H min לבין דוגמא : {7,5,9,4,8,11} דוגמא למצביע הדדי
Question 6 Store the elements in two heaps, Min-Heap H min and Max-Heap H max with mutual pointers, each element has a pointer to the element with the same value in the other heap. Init Build H min in O(n) and H max in O(n) Insert(x) Insert x to H min in O(log n) Insert x to H max in O(log n) Update the pointers in O(1) FindMin() Return the root of H min in O(1) FindMax Return the root of H max in O(1) DelMin Delete the minimum from H min in O(log n) Delete the same element from H max by following the mutual pointer in O(log n) DelMax Delete the maximum from H max in O(log n) Delete the same element from H min by following the mutual pointer in O(log n)